/**  
 * @parm  {tempObj,tempArr }
 * tempObj:需要清空属性值的对象，tempArr：需要清空tempObj中属性名
 **/
export const emptyAttribute = (tempObj : Record<PropertyKey, unknown>, tempArr : string[]) => {
	Object.keys(tempObj).forEach(key => {
		if (tempArr.includes(key)) {
			tempObj[key] = ''
		}
	})
}

/**  
 * @param  {tempObj,tempArr }
 * tempObj:需要删除属性值的对象，tempArr：需要删除empObj中属性名
 **/
export const deleteAttribute = (tempObj : Record<PropertyKey, unknown>, tempArr : string[]) => {
	Object.keys(tempObj).forEach(key => {
		if (tempArr.includes(key)) {
			delete tempObj[key]
		}
	})
}

/**  
 * 毫秒数转换正常时间
 * @param {msec}
 * msec：毫秒数    symbol：转换的符合
 **/
export const getTime = (msec : number) => {
	var date = new Date(msec); //获取一个时间对象
	let y = date.getFullYear(); // 获取完整的年份(4位,1970)
	let m = date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1; // 获取月份(0-11,0代表1月,用的时候记得加上1)
	let d = date.getDate() < 10 ? '0' + (date.getDate()) : date.getDate(); // 获取日(1-31)
	let t = date.getTime() < 10 ? '0' + (date.getTime()) : date.getTime(); // 获取时间(从1970.1.1开始的毫秒数)
	let h = date.getHours() < 10 ? '0' + (date.getHours()) : date.getHours(); // 获取小时数(0-23)
	let mm = date.getMinutes() < 10 ? '0' + (date.getMinutes()) : date.getMinutes(); // 获取分钟数(0-59)
	let s = date.getSeconds() < 10 ? '0' + (date.getSeconds()) : date.getSeconds(); // 获取秒数(0-59)
	return y + '-' + m + '-' + d + ' ' + h + ':' + mm + ':' + s;
}
// let time = 1684719582837;
// console.log('getTime(time * 1000)', getTime(time * 1000))  //  20xx-0x-0x 15:19:01


/**  
 * 毫秒数转换正常时间
 * @param {msec}
 * msec：毫秒数    symbol：转换的符合
 **/
export const getMonthDate = (msec ?: number) => {
	var date = msec ? new Date(msec) : new Date(); //获取一个时间对象
	let y = date.getFullYear(); // 获取完整的年份(4位,1970)
	let m = date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1; // 获取月份(0-11,0代表1月,用的时候记得加上1)
	return y + '-' + m;
}

/**  
 * @param  { 获取当前时分秒 }
 * 获取当前时分秒
 **/
export function getDateTime() {
	// console.log('DateDateDate',new Date(Date.now()).toLocaleString())
	let myDate = new Date();
	let str = myDate.toTimeString();
	let timeStr = str.substring(0, 5);
	// console.log('输出结果：', timeStr) //输出结果： 14:11:40
	return timeStr  // 返回时分秒
}

/**  
 * @param  { params }
 * params:深拷贝参数
 **/
export const deepCopy = (params : any) => {
	// structuredClone的兼容性： node 18版本 谷歌游览器需要100以上
	// return structuredClone(params)  
	// 筛选普通类型
	if (typeof params != 'object' || params == null) {
		return params
	}
	let clone = Array.isArray(params) ? [] : {}
	for (let key in params) {
		if (params.hasOwnProperty(key)) {
			clone[key] = deepCopy(params[key])
		}
	}
	return clone
}




/**  
 * @param  { obj } 深度克隆
 * obj:需要深度克隆的对象
 **/
export const getCloneDeep = (obj : any) => {
	var objClone = Array.isArray(obj) ? [] : {};
	if (obj && typeof obj === "object") {
		for (let key in obj) {
			if (obj.hasOwnProperty(key)) {
				if (obj[key] && typeof obj[key] === "object") {
					objClone[key] = getCloneDeep(obj[key]);
				} else {
					objClone[key] = obj[key];
				}
			}
		}
	}
	return objClone;
}


/**  
 * @param  { obj } 深度克隆 判断数据类型
 * obj:需要深度克隆的对象或数组
 **/
export const deepClone = (data : any) => {
	let type = getObjType(data)
	// console.log('typetype', type);
	let obj : any = null
	if (type === 'array') {
		obj = []
	} else if (type === 'object') {
		obj = {}
	} else {
		// 不再具有下一层次
		return data
	}
	if (type === 'array') {
		for (let i = 0, len = data.length; i < len; i++) {
			obj.push(deepClone(data[i]))
		}
	} else if (type === 'object') {
		for (let key in data) {
			obj[key] = deepClone(data[key])
		}
	}
	return obj
}
/**
 *  // 判断数据类型
 **/
const getObjType = (obj : any) => {
	let toString = Object.prototype.toString
	let map = {
		'[object Boolean]': 'boolean',
		'[object Number]': 'number',
		'[object String]': 'string',
		'[object Function]': 'function',
		'[object Array]': 'array',
		'[object Date]': 'date',
		'[object RegExp]': 'regExp',
		'[object Undefined]': 'undefined',
		'[object Null]': 'null',
		'[object Object]': 'object',
	}
	// if (obj instanceof Element) {
	//   return 'element'
	// }
	return map[toString.call(obj)]
}

/**
 * @name 防抖函数
 * @param {fn:callback,delay:Number} fn = 回调函数  delay = 毫秒数
 * 防抖的主要目的是确保事件触发后，在指定的时间内没有更多事件触发时才执行一次事件处理函数。它适用于需要等待用户停止操作后再执行的场景，如输入框输入验证、按钮点击事件等。
 **/
export function debounce(fn : any, delay : number = 1000) {
	let timer = null;
	if (timer) {
		clearTimeout(timer);
	}
	timer = setTimeout(() => {
		fn.apply(this, arguments);
	}, delay);
}

/**
 * 防抖
 * @param {要执行的函数} fn 
 * @param {在操作多长时间后可再执行，第一次立即执行} interval 
 */
export function getDebounce(fn : Function, interval : number, isFirstAutoRun) {
	let _self = fn;
	let timer = null;
	let first = true;

	if (isFirstAutoRun) {
		_self();
	}

	return function () {
		console.log('111111111111', first);
		let args = arguments;
		let _me = this;
		if (first) {
			first = false;
			_self.apply(_me, args);
		}

		if (timer) {
			clearTimeout(timer)
			// return false;
		}

		timer = setTimeout(function () {
			clearTimeout(timer);
			timer = null;
			_self.apply(_me, args);
		}, interval || 200);
	}
}


/**
 * @name 节流函数
 * @param {fn:callback,limit:Number} fn = 回调函数  limit = 毫秒数
 * 节流的主要目的是在一定时间内限制事件处理函数的执行频率，确保事件在一定时间间隔内最多执行一次。它适用于需要定期更新的操作，如滚动事件、搜索框输入等，以确保这些操作不会过于频繁地触发，从而减轻服务器和客户端的负担。
 **/
export function throttle(fn, limit) {
	let inThrottle;
	return () => {
		if (!inThrottle) {
			fn.apply(this, arguments);
			inThrottle = true;
			setTimeout(() => {
				inThrottle = false;
			}, limit);
		}
	};
}